package com.gongpingjialoan.utility;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.os.Environment;
import android.os.StatFs;
import android.util.Log;
import android.view.WindowManager;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 文件操作类文件操作的工具类，提供保存图片，获取图片，判断图片是否存在，删除图片的一些方法，这个类比较简单
 * 
 * @author zr
 * 
 */
public class FileUtil
{
    /**
     * sd卡的根目录
     */
    public static String mSdRootPath = Environment.getExternalStorageDirectory().getPath();
    
    /** 默认下载文件地址. */
    public static String downPathRootDir = File.separator + "hoperun/bodybuiding" + File.separator;
    
    /** 个人主页背景图片缓存路径 */
    private static String downPathImageDir = downPathRootDir + "personal_bg" + File.separator;
    
    /** 个人头像图片缓存路径 */
    private static String headPathImageDir = downPathRootDir + "head" + File.separator;
    
    /** 图片缓存路径 */
    public static String SHOW_IMG_DIR="show";
    
    /**
     * 手机的缓存根目录
     */
    private static String mDataRootPath = null;
    
    /**
     * 保存Image的目录名
     */
    private final static String FOLDER_NAME = downPathRootDir;
    
    /**
     * 保存文件的基本目录
     */
    private final static String BASE_DIR = "/hoperun/bodybuiding";
    
    /**
     * 保存录音的目录
     */
    private final static String RECORD_DIR = "/hoperun/bodybuiding/record";
    
    /**
     * FileUtil对象
     */
    private static FileUtil mFileUtil = null;
    
    /** 图片处理：裁剪. */
    public static final int CUTIMG = 0;
    
    /** 图片处理：缩放. */
    public static final int SCALEIMG = 1;
    
    /** 图片处理：不处理. */
    public static final int ORIGINALIMG = 2;
    
    private Context context;
    /**
     * 构造器
     * 
     * @param context
     */
    private  FileUtil(Context context)
    {
        mDataRootPath = context.getCacheDir().getPath();
        this.context = context;
    }
    
    /**
     * 单例获取FileUtil
     * 
     * @param context
     * @return
     */
    public static FileUtil getFileUtil(Context context)
    {
        if (mFileUtil == null)
        {
            mFileUtil = new FileUtil(context);
        }
        return mFileUtil;
    }
    
    /**
     * 获取储存Image的目录
     * 
     * @return
     */
    public static String getStorageDirectory()
    {
        return Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED) ? mSdRootPath + FOLDER_NAME
            : mDataRootPath + FOLDER_NAME;
    }
    
    /**
     * 保存Image的方法，有sd卡存储到sd卡，没有就存储到手机目录
     * 
     * @param fileName
     * @param bitmap
     * @throws IOException
     */
    public static void savaBitmap(String fileName, Bitmap bitmap)
        throws IOException
    {
        if (bitmap == null)
        {
            return;
        }
        String path = getStorageDirectory();
        File folderFile = new File(path);
        if (!folderFile.exists())
        {
            folderFile.mkdirs();
        }
        File file = new File(path  + fileName);
        file.createNewFile();
        FileOutputStream fos = new FileOutputStream(file);
        bitmap.compress(CompressFormat.JPEG, 100, fos);
        fos.flush();
        fos.close();
    }
    
    public static Bitmap getBitmap(String fileName,boolean isFullPath){
        String filePath = "";
        if(isFullPath){
            filePath = fileName;
        }else {
            filePath = getStorageDirectory() + File.separator + fileName;
        }
        Bitmap bitmap = null;
        try{
            BufferedInputStream in = new BufferedInputStream(new FileInputStream(new File(filePath)));
            
            BitmapFactory.Options opt = new BitmapFactory.Options(); 
            
            opt.inPreferredConfig = Bitmap.Config.RGB_565; 
             
            opt.inPurgeable = true; 
             
            opt.inInputShareable = true; 
            
            bitmap = BitmapFactory.decodeStream(in,null,opt);
            
        }catch(Exception e){
            Log.e("FileUtil", e.getMessage());
        }
        return bitmap;
    }
    /**
     * 从手机或者sd卡获取Bitmap
     * 
     * @param fileName
     * @return
     */
    public static Bitmap getBitmap(String fileName)
    {
        return getBitmap(fileName,false);
    }
    
    public Bitmap getBitmapByUrl(String url)
    {
        return BitmapFactory.decodeFile(url);
    }
    
    /**
     * 判断文件是否存在
     * 
     * @param fileName
     * @return
     */
    public static boolean isFileExists(String fileName)
    {
        return new File(getStorageDirectory() + File.separator + fileName).exists();
    }
    
    /**
     * 获取文件的大小
     * 
     * @param fileName
     * @return
     */
    public static long getFileSize(String fileName)
    {
        return new File(getStorageDirectory() + File.separator + fileName).length();
    }
    
    /**
     * 删除SD卡文件
     */
    public static void deleteFile()
    {
        File dirFile = new File(getStorageDirectory());
        if (!dirFile.exists())
        {
            return;
        }
        if (dirFile.isDirectory())
        {
            String[] children = dirFile.list();
            for (int i = 0; i < children.length; i++)
            {
                new File(dirFile, children[i]).delete();
            }
        }
        dirFile.delete();
    }
    
    /**
     * 删除指定路径文件
     * 
     * @param fileName
     * @throws IOException
     */
    public static boolean deleteFile(String fileName)
    {
        File file = new File(fileName);
        // 如果文件存在
        if (file.exists())
        {
            // 删除文件
            return file.delete();
        }
        return false;
    }
    
    /**
     * 
     * <一句话功能简述>存储卡是否可用 <功能详细描述>
     * 
     * @return 最后更新时间：<date> 修改履历：<修改内容>
     */
    public static boolean SDCardExists()
    {
        return Environment.getExternalStorageState().equals(android.os.Environment.MEDIA_MOUNTED);
    }
    
    /**
     * 
     * <一句话功能简述>获取录音目录 <功能详细描述>
     * 
     * @return 最后更新时间：<date> 修改履历：<修改内容>
     */
    public static String getRecordDir()
    {
        String dirPath = SDCardExists() ? mSdRootPath + BASE_DIR + RECORD_DIR : mDataRootPath + BASE_DIR + RECORD_DIR;
        
        // 目录不存在就创建
        File dir = new File(dirPath);
        if (!dir.exists() || !dir.isDirectory())
        {
            dir.mkdirs();
        }
        
        return dirPath;
    }
    
    /**
     * 获取等比缩放的图片 <一句话功能简述> <功能详细描述>
     * 
     * @param bm
     * @param context
     * @param size 缩放比例
     * @return 最后更新时间：<date> 修改履历：<修改内容>
     */
    public static Bitmap getBitMapOnBhrink(Bitmap bm, Context context, int size)
    {
        // 获得图片的宽
        int width = bm.getWidth();
        // 图片的高度
        int height = bm.getHeight();
        
        WindowManager wm = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
        int widthP = wm.getDefaultDisplay().getWidth();// 屏幕宽度
        if (width > widthP / size)
        {
            // 设置想要的大小
            int newWidth = widthP / size;
            // 计算缩放比例
            float scaleWidth = ((float)newWidth) / width;
            // 取得想要缩放的matrix参数
            Matrix matrix = new Matrix();
            matrix.postScale(scaleWidth, scaleWidth);
            bm = Bitmap.createBitmap(bm, 0, 0, width, height, matrix, true);
        }
        return bm;
    }
    
    /**
     * 描述：获取图片保存全路径.
     * 
     * @return 完成的存储目录
     */
    public static String getFullImageDownPathDir()
    {
        String pathDir = null;
        try
        {
            if (!isCanUseSD())
            {
                return null;
            }
            // 初始化图片保存路径
            File fileRoot = Environment.getExternalStorageDirectory();
            File dirFile = new File(fileRoot.getAbsolutePath() + FileUtil.downPathImageDir);
            if (!dirFile.exists())
            {
                dirFile.mkdirs();
            }
            pathDir = dirFile.getPath();
        }
        catch (Exception e)
        {
        }
        return pathDir;
    }
    
    /**
     * 
     * 头像
     * 
     * @return 最后更新时间：<date> 修改履历：<修改内容>
     */
    public static String getHeadImgPathDir()
    {
        String pathDir = null;
        try
        {
            if (!isCanUseSD())
            {
                return null;
            }
            // 初始化图片保存路径
            File fileRoot = Environment.getExternalStorageDirectory();
            File dirFile = new File(fileRoot.getAbsolutePath() + FileUtil.headPathImageDir);
            if (!dirFile.exists())
            {
                dirFile.mkdirs();
            }
            pathDir = dirFile.getPath();
        }
        catch (Exception e)
        {
        }
        return pathDir;
    }
    
    /**
     * 描述：获取src中的图片资源.
     * 
     * @param src 图片的src路径，如（“image/arrow.png”）
     * @return Bitmap 图片
     */
    public static Bitmap getBitmapFormSrc(String src)
    {
        Bitmap bit = null;
        try
        {
            bit = BitmapFactory.decodeStream(FileUtil.class.getResourceAsStream(src));
        }
        catch (Exception e)
        {
        }
        return bit;
    }
    
    /**
     * 描述：通过文件的本地地址从SD卡读取图片.
     * 
     * @param file the file
     * @return Bitmap 图片
     */
    public static Bitmap getBitmapFromSD(File file)
    {
       
        Bitmap bitmap = null;
        try
        {
            // SD卡是否存在
            if (!isCanUseSD())
            {
                return null;
            }
            // 文件是否存在
            if (!file.exists())
            {
                return null;
            }
            // 文件存在
            bitmap = AbImageUtil.originalImg(file);
            
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return bitmap;
    }
    
    /**
     * 描述：通过文件的本地地址从SD卡读取图片.
     * 
     * @param file the file
     * @param type 图片的处理类型（剪切或者缩放到指定大小，参考AbConstant类） 如果设置为原图，则后边参数无效，得到原图
     * @param newWidth 新图片的宽
     * @param newHeight 新图片的高
     * @return Bitmap 新图片
     */
    public static Bitmap getBitmapFromSD(File file, int type, int newWidth, int newHeight)
    {
        Bitmap bit = null;
        try
        {
            // SD卡是否存在
            if (!isCanUseSD())
            {
                return null;
            }
            
            if (type != ORIGINALIMG && (newWidth <= 0 || newHeight <= 0))
            {
                throw new IllegalArgumentException("缩放和裁剪图片的宽高设置不能小于0");
            }
            
            // 文件是否存在
            if (!file.exists())
            {
                return null;
            }
            
            // 文件存在
            if (type == CUTIMG)
            {
                bit = AbImageUtil.cutImg(file, newWidth, newHeight);
            }
            else if (type == SCALEIMG)
            {
                bit = AbImageUtil.scaleImg(file, newWidth, newHeight);
            }
            else
            {
                bit = AbImageUtil.originalImg(file);
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return bit;
    }
    
    /**
     * 描述：SD卡是否能用.
     * 
     * @return true 可用,false不可用
     */
    public static boolean isCanUseSD()
    {
        try
        {
            return Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return false;
    }
    
    /** * 获取手机内部剩余存储空间 * @return */
    public static long getAvailableInternalMemorySize()
    {
        File path = Environment.getDataDirectory();
        StatFs stat = new StatFs(path.getPath());
        long blockSize = stat.getBlockSize();
        long availableBlocks = stat.getAvailableBlocks();
        return availableBlocks * blockSize;
    }



    /**
     * 删除文件夹以及目录下的文件
     * @return  目录删除成功返回true，否则返回false
     */
    public static boolean deleteDirectory(File dirFile) {
        boolean flag = false;

        if (!dirFile.exists() || !dirFile.isDirectory()) {
            return false;
        }
        flag = true;
        File[] files = dirFile.listFiles();
        //遍历删除文件夹下的所有文件(包括子目录)
        for (int i = 0; i < files.length; i++) {
            if (files[i].isFile()) {
                //删除子文件
                flag = deleteFile(files[i].getAbsolutePath());
                if (!flag) break;
            } else {
                //删除子目录
                flag = deleteDirectory(files[i]);
                if (!flag) break;
            }
        }
        if (!flag) return false;
        //删除当前空目录
        return dirFile.delete();
    }

}
